// 网卡监控排序器
class NetworkSorter {
    constructor() {
        this.currentSortField = null;
        this.currentSortOrder = 'desc';
    }

    // 点击表头排序
    handleHeaderClick(field) {
        // 如果点击的是当前排序字段，则循环切换状态
        if (this.currentSortField === field) {
            if (this.currentSortOrder === 'asc') {
                // 第二次点击：降序
                this.currentSortOrder = 'desc';
            } else if (this.currentSortOrder === 'desc') {
                // 第三次点击：恢复默认状态（无排序）
                this.currentSortField = null;
                this.currentSortOrder = null;
            }
        } else {
            // 如果是新字段，第一次点击设置为升序
            this.currentSortField = field;
            this.currentSortOrder = 'asc';
        }
        
        // 更新表头样式
        this.updateHeaderStyles();
        
        // 触发重新渲染
        if (window.renderInterfacesTable) {
            window.renderInterfacesTable();
        }
    }

    // 更新表头样式
    updateHeaderStyles() {
        // 清除所有表头的排序样式
        document.querySelectorAll('.interfaces-table th.sortable').forEach(th => {
            th.classList.remove('active', 'sort-asc', 'sort-desc');
        });
        
        // 为当前排序字段添加样式
        if (this.currentSortField) {
            const activeHeader = document.querySelector(`.interfaces-table th[data-sort="${this.currentSortField}"]`);
            if (activeHeader) {
                activeHeader.classList.add('active');
                activeHeader.classList.add(this.currentSortOrder === 'asc' ? 'sort-asc' : 'sort-desc');
            }
        }
    }

    // 获取排序键值
    getSortValue(item, field) {
        switch (field) {
            case 'name':
                return (item.name || '').toLowerCase();
            case 'received_mbps':
                return item.received_mbps || 0;
            case 'sent_mbps':
                return item.sent_mbps || 0;
            case 'total_received_gb':
                return item.total_received_gb || 0;
            case 'total_sent_gb':
                return item.total_sent_gb || 0;
            case 'dropped':
                return item.dropped || 0;
            default:
                return 0;
        }
    }

    // 排序网卡数据
    sortInterfaces(interfaces) {
        if (!interfaces || interfaces.length === 0 || !this.currentSortField) {
            return interfaces;
        }

        return [...interfaces].sort((a, b) => {
            const aValue = this.getSortValue(a, this.currentSortField);
            const bValue = this.getSortValue(b, this.currentSortField);
            
            let result = 0;
            if (typeof aValue === 'string') {
                result = aValue.localeCompare(bValue);
            } else {
                result = aValue - bValue;
            }
            
            return this.currentSortOrder === 'asc' ? result : -result;
        });
    }

    // 设置表头点击事件监听器
    setupHeaderEventListeners() {
        document.querySelectorAll('.interfaces-table th.sortable').forEach(th => {
            th.addEventListener('click', () => {
                const field = th.getAttribute('data-sort');
                if (field) {
                    this.handleHeaderClick(field);
                }
            });
        });
    }

    // 获取当前排序信息（用于调试）
    getCurrentSortInfo() {
        return {
            field: this.currentSortField,
            order: this.currentSortOrder
        };
    }
}

// 创建全局实例
window.networkSorter = new NetworkSorter();

// 页面加载完成后设置事件监听器
document.addEventListener('DOMContentLoaded', () => {
    // 延迟设置，确保表格已经渲染
    setTimeout(() => {
        window.networkSorter.setupHeaderEventListeners();
    }, 100);
});